{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Batch Normalization\n",
    "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \n",
    "One idea along these lines is batch normalization which was proposed by [1] in 2015.\n",
    "\n",
    "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
    "\n",
    "The authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
    "\n",
    "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
    "\n",
    "[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
      "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
      "\tThe instructions to do this will be given in a section of the notebook below.\n",
      "\tThere will be an option for Colab users and another for Jupyter (local) users.\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n",
    "\n",
    "def print_mean_std(x,axis=0):\n",
    "    print('  means: ', x.mean(axis=axis))\n",
    "    print('  stds:  ', x.std(axis=axis))\n",
    "    print() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: forward\n",
    "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n",
    "\n",
    "Referencing the paper linked to above in [1] may be helpful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
      "  stds:   [27.18502186 34.21455511 37.68611762]\n",
      "\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "  means:  [5.99520433e-17 6.93889390e-17 8.32667268e-19]\n",
      "  stds:   [0.99999999 1.         1.        ]\n",
      "\n",
      "After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n",
      "  means:  [11. 12. 13.]\n",
      "  stds:   [0.99999999 1.99999999 2.99999999]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print_mean_std(a,axis=0)\n",
    "\n",
    "gamma = np.ones((D3,))\n",
    "beta = np.zeros((D3,))\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)\n",
    "\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
      "  stds:   [1.01531428 1.01238373 0.97819988]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1)\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: backward\n",
    "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
    "\n",
    "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
    "\n",
    "Once you have finished, run the following to numerically check your backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.6674644627614554e-09\n",
      "dgamma error:  7.417225040694815e-13\n",
      "dbeta error:  2.379446949959628e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "#You should expect to see relative errors between 1e-13 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: alternative backward\n",
    "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n",
    "\n",
    "Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too!  \n",
    "\n",
    "In the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n",
    "\n",
    "\n",
    "\n",
    "we first calculate the mean $\\mu$ and variance $v$.\n",
    "With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$  and normalized data $Y$.\n",
    "The equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n",
    "\n",
    "\\begin{align}\n",
    "& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k  &  v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n",
    "& \\sigma=\\sqrt{v+\\epsilon}         &  y_i=\\frac{x_i-\\mu}{\\sigma}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://raw.githubusercontent.com/cs231n/cs231n.github.io/master/assets/a2/batchnorm_graph.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "The meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n",
    "\n",
    "The unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n",
    "$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n",
    "$\\frac{\\partial \\sigma}{\\partial v}$, \n",
    "$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\n",
    "and then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n",
    "\n",
    "If it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n",
    "\n",
    "You should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n",
    "\n",
    "After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx difference:  1.0993932443869425e-12\n",
      "dgamma difference:  0.0\n",
      "dbeta difference:  0.0\n",
      "speedup: 1.63x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fully Connected Nets with Batch Normalization\n",
    "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
    "\n",
    "Concretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
    "\n",
    "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.214515527540361\n",
      "W1 relative error: 1.76e-06\n",
      "W2 relative error: 2.16e-05\n",
      "W3 relative error: 1.60e-09\n",
      "b1 relative error: 3.66e-08\n",
      "b2 relative error: 6.22e-07\n",
      "b3 relative error: 6.50e-11\n",
      "beta1 relative error: 5.72e-09\n",
      "beta2 relative error: 9.71e-08\n",
      "gamma1 relative error: 5.70e-09\n",
      "gamma2 relative error: 4.01e-07\n",
      "\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.06650976678197\n",
      "W1 relative error: 1.22e-03\n",
      "W2 relative error: 6.93e-06\n",
      "W3 relative error: 4.84e-09\n",
      "b1 relative error: 4.44e-03\n",
      "b2 relative error: 4.94e-07\n",
      "b3 relative error: 2.22e-10\n",
      "beta1 relative error: 1.27e-08\n",
      "beta2 relative error: 6.93e-08\n",
      "gamma1 relative error: 7.36e-09\n",
      "gamma2 relative error: 9.00e-08\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "# You should expect losses between 1e-4~1e-10 for W, \n",
    "# losses between 1e-08~1e-10 for b,\n",
    "# and losses between 1e-08~1e-09 for beta and gammas.\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            normalization='batchnorm')\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "#     print(name, grad_num.shape, grads[name].shape)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batchnorm for deep networks\n",
    "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solver with batch norm:\n",
      "(Iteration 1 / 200) loss: 2.330132\n",
      "(Epoch 0 / 10) train acc: 0.137000; val_acc: 0.128000\n",
      "(Epoch 1 / 10) train acc: 0.302000; val_acc: 0.257000\n",
      "(Iteration 21 / 200) loss: 1.992479\n",
      "(Epoch 2 / 10) train acc: 0.394000; val_acc: 0.305000\n",
      "(Iteration 41 / 200) loss: 1.507852\n",
      "(Epoch 3 / 10) train acc: 0.474000; val_acc: 0.334000\n",
      "(Iteration 61 / 200) loss: 1.466937\n",
      "(Epoch 4 / 10) train acc: 0.556000; val_acc: 0.338000\n",
      "(Iteration 81 / 200) loss: 1.348399\n",
      "(Epoch 5 / 10) train acc: 0.622000; val_acc: 0.322000\n",
      "(Iteration 101 / 200) loss: 1.055571\n",
      "(Epoch 6 / 10) train acc: 0.664000; val_acc: 0.361000\n",
      "(Iteration 121 / 200) loss: 1.208816\n",
      "(Epoch 7 / 10) train acc: 0.729000; val_acc: 0.344000\n",
      "(Iteration 141 / 200) loss: 1.037898\n",
      "(Epoch 8 / 10) train acc: 0.747000; val_acc: 0.342000\n",
      "(Iteration 161 / 200) loss: 0.732457\n",
      "(Epoch 9 / 10) train acc: 0.808000; val_acc: 0.328000\n",
      "(Iteration 181 / 200) loss: 0.754469\n",
      "(Epoch 10 / 10) train acc: 0.856000; val_acc: 0.354000\n",
      "\n",
      "Solver without batch norm:\n",
      "(Iteration 1 / 200) loss: 2.303613\n",
      "(Epoch 0 / 10) train acc: 0.163000; val_acc: 0.171000\n",
      "(Epoch 1 / 10) train acc: 0.215000; val_acc: 0.170000\n",
      "(Iteration 21 / 200) loss: 1.893966\n",
      "(Epoch 2 / 10) train acc: 0.255000; val_acc: 0.252000\n",
      "(Iteration 41 / 200) loss: 2.041678\n",
      "(Epoch 3 / 10) train acc: 0.354000; val_acc: 0.262000\n",
      "(Iteration 61 / 200) loss: 1.753824\n",
      "(Epoch 4 / 10) train acc: 0.375000; val_acc: 0.279000\n",
      "(Iteration 81 / 200) loss: 1.578952\n",
      "(Epoch 5 / 10) train acc: 0.422000; val_acc: 0.306000\n",
      "(Iteration 101 / 200) loss: 1.579314\n",
      "(Epoch 6 / 10) train acc: 0.443000; val_acc: 0.296000\n",
      "(Iteration 121 / 200) loss: 1.409140\n",
      "(Epoch 7 / 10) train acc: 0.486000; val_acc: 0.281000\n",
      "(Iteration 141 / 200) loss: 1.215799\n",
      "(Epoch 8 / 10) train acc: 0.577000; val_acc: 0.306000\n",
      "(Iteration 161 / 200) loss: 1.203409\n",
      "(Epoch 9 / 10) train acc: 0.609000; val_acc: 0.310000\n",
      "(Iteration 181 / 200) loss: 0.903254\n",
      "(Epoch 10 / 10) train acc: 0.647000; val_acc: 0.330000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "print('Solver with batch norm:')\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True,print_every=20)\n",
    "bn_solver.train()\n",
    "\n",
    "print('\\nSolver without batch norm:')\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=20)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n",
    "    \"\"\"utility function for plotting training history\"\"\"\n",
    "    plt.title(title)\n",
    "    plt.xlabel(label)\n",
    "    bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n",
    "    bl_plot = plot_fn(baseline)\n",
    "    num_bn = len(bn_plots)\n",
    "    for i in range(num_bn):\n",
    "        label='with_norm'\n",
    "        if labels is not None:\n",
    "            label += str(labels[i])\n",
    "        plt.plot(bn_plots[i], bn_marker, label=label)\n",
    "    label='baseline'\n",
    "    if labels is not None:\n",
    "        label += str(labels[0])\n",
    "    plt.plot(bl_plot, bl_marker, label=label)\n",
    "    plt.legend(loc='lower center', ncol=num_bn+1) \n",
    "\n",
    "    \n",
    "plt.subplot(3, 1, 1)\n",
    "plot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n",
    "                      lambda x: x.loss_history, bl_marker='o', bn_marker='o')\n",
    "plt.subplot(3, 1, 2)\n",
    "plot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "plt.subplot(3, 1, 3)\n",
    "plot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and initialization\n",
    "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
    "\n",
    "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers_ws = {}\n",
    "solvers_ws = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "    print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "    bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "    bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "    bn_solver.train()\n",
    "    bn_solvers_ws[weight_scale] = bn_solver\n",
    "\n",
    "    solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "    solver.train()\n",
    "    solvers_ws[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1:\n",
    "Describe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?\n",
    "\n",
    "## Answer:\n",
    "For models with batch normalization: the effect of the scale of weight is less obvious, and the model is much rubust.\n",
    "\n",
    "For models without batch normalization, the effect pf the scale of weight is much obvious, and a little change will cause a huge difference! By observing the loss, it can be found that when the scale of weight is larger than `1`, the loss will increase crazily!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and batch size\n",
    "We will now run a small experiment to study the interaction of batch normalization and batch size.\n",
    "\n",
    "The first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    }
   ],
   "source": [
    "def run_batchsize_experiments(normalization_mode):\n",
    "    np.random.seed(231)\n",
    "    # Try training a very deep net with batchnorm\n",
    "    hidden_dims = [100, 100, 100, 100, 100]\n",
    "    num_train = 1000\n",
    "    small_data = {\n",
    "      'X_train': data['X_train'][:num_train],\n",
    "      'y_train': data['y_train'][:num_train],\n",
    "      'X_val': data['X_val'],\n",
    "      'y_val': data['y_val'],\n",
    "    }\n",
    "    n_epochs=10\n",
    "    weight_scale = 2e-2\n",
    "    batch_sizes = [5,10,50]\n",
    "    lr = 10**(-3.5)\n",
    "    solver_bsize = batch_sizes[0]\n",
    "\n",
    "    print('No normalization: batch size = ',solver_bsize)\n",
    "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=n_epochs, batch_size=solver_bsize,\n",
    "                    update_rule='adam',\n",
    "                    optim_config={\n",
    "                      'learning_rate': lr,\n",
    "                    },\n",
    "                    verbose=False)\n",
    "    solver.train()\n",
    "    \n",
    "    bn_solvers = []\n",
    "    for i in range(len(batch_sizes)):\n",
    "        b_size=batch_sizes[i]\n",
    "        print('Normalization: batch size = ',b_size)\n",
    "        bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n",
    "        bn_solver = Solver(bn_model, small_data,\n",
    "                        num_epochs=n_epochs, batch_size=b_size,\n",
    "                        update_rule='adam',\n",
    "                        optim_config={\n",
    "                          'learning_rate': lr,\n",
    "                        },\n",
    "                        verbose=False)\n",
    "        bn_solver.train()\n",
    "        bn_solvers.append(bn_solver)\n",
    "        \n",
    "    return bn_solvers, solver, batch_sizes\n",
    "\n",
    "batch_sizes = [5,10,50]\n",
    "bn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2:\n",
    "Describe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n",
    "\n",
    "## Answer:\n",
    "1. With BN, the validation accuracy is always higher than the basline;\n",
    "\n",
    "2. With BN, th ehigher the BS, the higher the Training accuracy;\n",
    "\n",
    "3. With BN, though by increasing BS, training acc will increase, but the vali acc may not.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization\n",
    "Batch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n",
    "\n",
    "Several alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n",
    "\n",
    "[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "Which of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n",
    "\n",
    "1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n",
    "2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1.  \n",
    "3. Subtracting the mean image of the dataset from each image in the dataset.\n",
    "4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n",
    "\n",
    "## Answer:\n",
    "- LN: 1, 2\n",
    "- BN: 3, 4\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization: Implementation\n",
    "\n",
    "Now you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n",
    "\n",
    "Here's what you need to do:\n",
    "\n",
    "* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`. \n",
    "\n",
    "Run the cell below to check your results.\n",
    "* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the second cell below to check your results.\n",
    "* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n",
    "\n",
    "Run the third cell below to run the batch size experiment on layer normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before layer normalization:\n",
      "  means:  [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n",
      "  stds:   [10.07429373 28.39478981 35.28360729  4.01831507]\n",
      "\n",
      "After layer normalization (gamma=1, beta=0)\n",
      "  means:  [ 4.81096644e-16 -7.40148683e-17  2.22044605e-16 -5.92118946e-16]\n",
      "  stds:   [0.99999995 0.99999999 1.         0.99999969]\n",
      "\n",
      "After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n",
      "  means:  [5. 5. 5. 5.]\n",
      "  stds:   [2.99999985 2.99999998 2.99999999 2.99999907]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after layer normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 =4, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before layer normalization:')\n",
    "print_mean_std(a,axis=1)\n",
    "\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After layer normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)\n",
    "\n",
    "gamma = np.asarray([3.0,3.0,3.0])\n",
    "beta = np.asarray([5.0,5.0,5.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.0148552   0.01032912 -0.01190652  0.04456401 -0.02813141]\n",
      " [ 0.06974204 -0.02127583 -0.00771128 -0.04754429  0.00678935]\n",
      " [-0.01334007 -0.01950385  0.00393253  0.09003202 -0.06112062]\n",
      " [ 0.07764743  0.38964293  0.06352497 -0.56141532  0.0306    ]] \n",
      "\n",
      " [[-0.0148552   0.01032912 -0.01190652  0.04456401 -0.02813141]\n",
      " [ 0.06974204 -0.02127583 -0.00771128 -0.04754429  0.00678935]\n",
      " [-0.01334007 -0.01950385  0.00393253  0.09003202 -0.06112062]\n",
      " [ 0.07764743  0.38964293  0.06352497 -0.56141532  0.0306    ]]\n",
      "dx error:  2.1072792574426117e-09\n",
      "dgamma error:  4.519489546032799e-12\n",
      "dbeta error:  2.5842537629899423e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "ln_param = {}\n",
    "fx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\n",
    "fg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\n",
    "fb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = layernorm_forward(x, gamma, beta, ln_param)\n",
    "dx, dgamma, dbeta = layernorm_backward(dout, cache)\n",
    "print(dx_num, '\\n\\n', dx)\n",
    "#You should expect to see relative errors between 1e-12 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization and batch size\n",
    "\n",
    "We will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 4:\n",
    "When is layer normalization likely to not work well, and why?\n",
    "\n",
    "1. Using it in a very deep network\n",
    "2. Having a very small dimension of features\n",
    "3. Having a high regularization term\n",
    "\n",
    "\n",
    "## Answer:\n",
    "- [2] When feature dimention is small, it's likely that the mean and variance will be random, which could not work well!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
